﻿// Autore: Mattia Barrasso

using System.Linq;
using NUnit.Framework;
using RecipesManager.Data;
using TechTalk.SpecFlow;

namespace RecipesManager.Specs.Categoria
{
    [Binding]
    [Scope(Feature = "AggiuntaCategoria")]
    public class AggiuntaCategoria_Steps : CategorieBDD
    {
        [BeforeScenario]
        public new void SetUpScenario()
        {
            base.SetUpScenario();
        }

        [AfterScenario]
        protected new void TearDownScenario()
        {
            base.TearDownScenario();
        }

        [Given(Regex = @"la categoria ([a-zA-Z]+) non esiste")]
        public void DatoCategoriaNonEsistente(string categoria)
        {
            Assert.That(!Manager.Categories.Contains(categoria));
        }

        [Given(Regex = @"la categoria ([a-zA-Z]+) esiste")]
        public void DatoCategoriaEsistente(string categoria)
        {
            Manager.Categories.Add(categoria);
            Assert.That(Manager.Categories.Contains(categoria));
        }

        [Given(Regex = @"([a-zA-Z]+) ha come categorie inferiori ([a-zA-Z]+)")]
        public void DataSottoCategoria(string categoria, string subCategoria)
        {
            Assert.That(Manager.Categories.Contains(categoria));
            Assert.That(Manager.Categories.Contains(subCategoria));
            Manager.Categories[categoria].Children.Add(subCategoria);
            Assert.That(Manager.Categories[categoria].Children.Contains(subCategoria));
        }

        [Given(Regex = @"([a-zA-Z]+) ha come categorie superiori ([a-zA-Z]+)")]
        public void DataSuperCategoria(string categoria, string superCategoria)
        {
            Assert.That(Manager.Categories.Contains(categoria));
            Assert.That(Manager.Categories.Contains(superCategoria));
            Manager.Categories[categoria].Parents.Add(superCategoria);
            Assert.That(Manager.Categories[categoria].Parents.Contains(superCategoria));
        }

        [Given(Regex = @"ho inserito i valori")]
        public void DatoCategoriaInserita(Table table)
        {
            NavigateToCategories();
            base.GetCategoriesUi();
            _newCategory.Click();
            base.GetSingleCategoryUi();

            foreach (var row in table.Rows)
            {
                if (row["Attributi"].Equals("Nome"))
                {
                    _categoryName.SetValue(row["Valori"]);
                }
                else if(row["Attributi"].Equals("Sub"))
                {
                    //Assert.That(_subCategories.Items.Any(item => item.Text.Equals(row["Valori"])));
                    _subCategories.Click();
                    _subCategories.Select(row["Valori"]);
                    _addSubCategory.Click();
                }
                else if (row["Attributi"].Equals("Super"))
                {
                    Assert.That(_superCategories.Items.Any(item => item.Text.Equals(row["Valori"])));
                    _superCategories.Click();
                    _superCategories.Select(row["Valori"]);
                    _addSuperCategory.Click();
                }
                else
                {
                    Assert.Fail("Table");
                }
            }
        }

        [When(Regex = @"salvo")]
        public void QuandoSalvo()
        {
            if(_saveCategory.Enabled)
                _saveCategory.Click();
        }

        [When(Regex = @"visiono le potenziali categorie superiori")]
        public void QuandoVisionoLeCategorieSuperiori()
        {
            _superCategories.Click();
        }

        [When(Regex = @"visiono le potenziali categorie inferiori")]
        public void QuandoVisionoLeCategorieInferiori()
        {
            _subCategories.Click();
        }

        [Then(Regex = @"la lista delle categorie inferiori contiene ([0-9]+) elementi")]
        public void AlloraEsistonoNCategorieInferioriPotenziali(int nSubCategorie)
        {
            Assert.That(_subCategories.Items.Count == nSubCategorie);
        }

        [Then(Regex = @"la lista delle categorie superiori contiene ([0-9]+) elementi")]
        public void AlloraEsistonoNCategorieSuperioriPotenziali(int nSuperCategorie)
        {
            Assert.That(_superCategories.Items.Count == nSuperCategorie);
        }

        [Then(Regex = @"la categoria ([a-zA-Z]+) esiste")]
        public void AlloraCategoriaEsiste(string categoria)
        {
            Assert.That(Manager.Categories.Contains(categoria));
            Assert.That(_categories.Items.Any(item => item.Text.Equals(categoria)));
        }

        [Then(Regex = @"la categoria ([a-zA-Z]+) non esiste")]
        public void AlloraCategoriaNonEsiste(string categoria)
        {
            Assert.That(!Manager.Categories.Contains(categoria));
            Assert.That(!_categories.Items.Any(item => item.Text.Equals(categoria)));
        }

        [Then(Regex = @"la categoria ([a-zA-Z]+) ha ([0-9]+) categorie superiori")]
        public void AlloraHaNCategorieSuperiori(string categoria, int nCategorieSuperiori)
        {
            Assert.That(Manager.Categories[categoria].Parents.Count == nCategorieSuperiori);
            Assert.That(_selectedSuperCategories.Items.Count == nCategorieSuperiori);
        }

        [Then(Regex = @"la categoria ([a-zA-Z]+) ha ([0-9]+) categorie inferiori")]
        public void AlloraHaNCategorieInferiori(string categoria, int nCategorieInferiori)
        {
            Assert.That(Manager.Categories[categoria].Children.Count == nCategorieInferiori);
            Assert.That(_selectedSubCategories.Items.Count == nCategorieInferiori);
        }

        [Then(Regex = @"la categoria ha come categorie inferiori")]
        public void AlloraHaComeCategorieInferiori(Table table)
        {
            foreach (var row in table.Rows)
            {
                if (row["Attributi"].Equals("Nome"))
                {
                    Assert.That(_selectedSubCategories.Items.Any(item => item.Text.Equals(row["Valori"])));
                }
                else
                {
                    Assert.Fail("Table");
                }
            }
        }
        [Then(Regex = @"la categoria ha come categorie superiori")]
        public void AlloraHaComeCategorieSuperiori(Table table)
        {
            foreach (var row in table.Rows)
            {
                if (row["Attributi"].Equals("Nome"))
                {
                    Assert.That(_selectedSuperCategories.Items.Any(item => item.Text.Equals(row["Valori"])));
                }
                else
                {
                    Assert.Fail("Table");
                }
            }
        }

        [Then(Regex = @"l'operazione non ha successo")]
        public void AlloraInsuccesso()
        {
            Assert.That(MainWindow.ModalWindows().Count != 0 || !_saveCategory.Enabled);
        }

        [Then(Regex = @"l'operazione ha successo")]
        public void AlloraSuccesso()
        {
            Assert.That(MainWindow.ModalWindows().Count == 0);
        }
    }
}
